# -*- coding: utf-8 -*-
from gi.repository import Pango

def get_context(display=None, screen=None):
    """    Retrieves a #PangoContext appropriate for rendering with
    Xft fonts on the given screen of the given display.
    @param display: an X display.
    @param screen: an X screen.
    @type display: xlib.Display
    @type screen: int
    @returns: the new #PangoContext.
    @rtype: Pango.Context
    """
    return object

def get_font_map(display=None, screen=None):
    """    Returns the #PangoXftFontMap for the given display and screen.
    The fontmap is owned by Pango and will be valid until
    the display is closed.
    @param display: an X display
    @param screen: the screen number of a screen within @display
    @type display: xlib.Display
    @type screen: int
    @returns: a #PangoFontMap object, owned by Pango.
    @rtype: Pango.FontMap
    """
    return object

def picture_render(display=None, src_picture=None, dest_picture=None, font=None, glyphs=None, x=None, y=None):
    """    Renders a #PangoGlyphString onto an Xrender <type>Picture</type> object.
    @param display: an X display
    @param src_picture: the source picture to draw the string with
    @param dest_picture: the destination picture to draw the string onto
    @param font: the font in which to draw the string
    @param glyphs: the glyph string to draw
    @param x: the x position of start of string (in pixels)
    @param y: the y position of baseline (in pixels)
    @type display: xlib.Display
    @type src_picture: xlib.Picture
    @type dest_picture: xlib.Picture
    @type font: Pango.Font
    @type glyphs: Pango.GlyphString
    @type x: int
    @type y: int
    @returns: 
    @rtype: None
    """
    return object

def render(draw=None, color=None, font=None, glyphs=None, x=None, y=None):
    """    Renders a #PangoGlyphString onto an <type>XftDraw</type> object wrapping an X drawable.
    @param draw: the <type>XftDraw</type> object.
    @param color: the color in which to draw the string
    @param font: the font in which to draw the string
    @param glyphs: the glyph string to draw
    @param x: the x position of start of string (in pixels)
    @param y: the y position of baseline (in pixels)
    @type draw: xft.Draw
    @type color: xft.Color
    @type font: Pango.Font
    @type glyphs: Pango.GlyphString
    @type x: int
    @type y: int
    @returns: 
    @rtype: None
    """
    return object

def render_layout(draw=None, color=None, layout=None, x=None, y=None):
    """    Render a #PangoLayout onto a #XftDraw
    @param draw: an #XftDraw
    @param color: the foreground color in which to draw the layout             (may be overridden by color attributes)
    @param layout: a #PangoLayout
    @param x: the X position of the left of the layout (in Pango units)
    @param y: the Y position of the top of the layout (in Pango units)
    @type draw: xft.Draw
    @type color: xft.Color
    @type layout: Pango.Layout
    @type x: int
    @type y: int
    @returns: 
    @rtype: None
    """
    return object

def render_layout_line(draw=None, color=None, line=None, x=None, y=None):
    """    Render a #PangoLayoutLine onto a #XftDraw
    @param draw: an #XftDraw
    @param color: the foreground color in which to draw the layout line             (may be overridden by color attributes)
    @param line: a #PangoLayoutLine
    @param x: the x position of start of string (in Pango units)
    @param y: the y position of baseline (in Pango units)
    @type draw: xft.Draw
    @type color: xft.Color
    @type line: Pango.LayoutLine
    @type x: int
    @type y: int
    @returns: 
    @rtype: None
    """
    return object

def render_transformed(draw=None, color=None, matrix=None, font=None, glyphs=None, x=None, y=None):
    """    Renders a #PangoGlyphString onto a #XftDraw, possibly
    transforming the layed-out coordinates through a transformation
    matrix. Note that the transformation matrix for @font is not
    changed, so to produce correct rendering results, the @font
    must have been loaded using a #PangoContext with an identical
    transformation matrix to that passed in to this function.
    @param draw: an #XftDraw
    @param color: the color in which to draw the glyphs
    @param matrix: a #PangoMatrix, or %NULL to use an identity           transformation
    @param font: the font in which to draw the string
    @param glyphs: the glyph string to draw
    @param x: the x position of the start of the string (in Pango           units in user space coordinates)
    @param y: the y position of the baseline (in Pango units           in user space coordinates)
    @type draw: xft.Draw
    @type color: xft.Color
    @type matrix: Pango.Matrix
    @type font: Pango.Font
    @type glyphs: Pango.GlyphString
    @type x: int
    @type y: int
    @returns: 
    @rtype: None
    """
    return object

def set_default_substitute(display=None, screen=None, func=None, data=None, notify=None):
    """    Sets a function that will be called to do final configuration
    substitution on a #FcPattern before it is used to load
    the font. This function can be used to do things like set
    hinting and antialiasing options.
    @param display: an X Display
    @param screen: the screen number of a screen within @display
    @param func: function to call to to do final config tweaking        on #FcPattern objects.
    @param data: data to pass to @func
    @param notify: function to call when @data is no longer used.
    @type display: xlib.Display
    @type screen: int
    @type func: SubstituteFunc
    @type data: gpointer
    @type notify: GLib.DestroyNotify
    @returns: 
    @rtype: None
    """
    return object

def shutdown_display(display=None, screen=None):
    """    Release any resources that have been cached for the
    combination of @display and @screen. Note that when the
    X display is closed, resources are released automatically,
    without needing to call this function.
    @param display: an X display
    @param screen: the screen number of a screen within @display
    @type display: xlib.Display
    @type screen: int
    @returns: 
    @rtype: None
    """
    return object

def substitute_changed(display=None, screen=None):
    """    Call this function any time the results of the
    default substitution function set with
    pango_xft_set_default_substitute() change.
    That is, if your substitution function will return different
    results for the same input pattern, you must call this function.
    @param display: an X Display
    @param screen: the screen number of a screen within @display
    @type display: xlib.Display
    @type screen: int
    @returns: 
    @rtype: None
    """
    return object


class Font(Pango.Font):
    """#PangoXftFont is an implementation of #PangoFcFont using the Xft
library for rendering.  It is used in conjunction with #PangoXftFontMap."""
    @staticmethod
    def get_display(font=None):
        """        Returns the X display of the XftFont of a font.
        @param font: a #PangoFont.
        @type font: Pango.Font
        @returns: the X display of the XftFont associated to @font.
        @rtype: xlib.Display
        """
        return object
    @staticmethod
    def get_font(font=None):
        """        Returns the XftFont of a font.
        @param font: a #PangoFont.
        @type font: Pango.Font
        @returns: the XftFont associated to @font, or %NULL if @font is %NULL.
        @rtype: xft.Font
        """
        return object
    @staticmethod
    def get_glyph(font=None, wc=None):
        """        Gets the glyph index for a given Unicode character
        for @font. If you only want to determine
        whether the font has the glyph, use pango_xft_font_has_char().
        
        Use pango_fc_font_get_glyph() instead.
        @param font: a #PangoFont for the Xft backend
        @param wc: Unicode codepoint to look up
        @type font: Pango.Font
        @type wc: gunichar
        @returns: the glyph index, or 0, if the Unicode  character does not exist in the font.
        @rtype: int
        """
        return object
    @staticmethod
    def get_unknown_glyph(font=None, wc=None):
        """        Returns the index of a glyph suitable for drawing @wc as an
        unknown character.
        
        Use PANGO_GET_UNKNOWN_GLYPH() instead.
        @param font: a #PangoFont.
        @param wc: the Unicode character for which a glyph is needed.
        @type font: Pango.Font
        @type wc: gunichar
        @returns: a glyph index into @font.
        @rtype: Pango.Glyph
        """
        return object
    @staticmethod
    def has_char(font=None, wc=None):
        """        Determines whether @font has a glyph for the codepoint @wc.
        
        Use pango_fc_font_has_char() instead.
        @param font: a #PangoFont for the Xft backend
        @param wc: Unicode codepoint to look up
        @type font: Pango.Font
        @type wc: gunichar
        @returns: %TRUE if @font has the requested codepoint.
        @rtype: bool
        """
        return object
    @staticmethod
    def lock_face(font=None):
        """        Gets the FreeType <type>FT_Face</type> associated with a font,
        This face will be kept around until you call
        pango_xft_font_unlock_face().
        
        Use pango_fc_font_lock_face() instead.
        @param font: a #PangoFont.
        @type font: Pango.Font
        @returns: the FreeType <type>FT_Face</type> associated with @font.
        @rtype: freetype2.Face
        """
        return object
    @staticmethod
    def unlock_face(font=None):
        """        Releases a font previously obtained with
        pango_xft_font_lock_face().
        
        Use pango_fc_font_unlock_face() instead.
        @param font: a #PangoFont.
        @type font: Pango.Font
        @returns: 
        @rtype: None
        """
        return object


class FontMap(Pango.FontMap):
    """#PangoXftFontMap is an implementation of #PangoFcFontMap suitable for
the Xft library as the renderer.  It is used in to create fonts of
type #PangoXftFont."""


class Renderer(Pango.Renderer):
    """#PangoXftRenderer is a subclass of #PangoRenderer used for rendering
with Pango's Xft backend. It can be used directly, or it can be
further subclassed to modify exactly how drawing of individual
elements occurs."""
    
    def __init__(self, display=None, screen=None):
        """        Create a new #PangoXftRenderer to allow rendering Pango objects
        with the Xft library. You must call pango_xft_renderer_set_draw() before
        using the renderer.
        @param display: an X display
        @param screen: the index of the screen for @display to which rendering will be done
        @type display: xlib.Display
        @type screen: int
        @returns: Newly created Renderer
        @rtype: Renderer
        """
        return object
    @staticmethod
    def new(display=None, screen=None):
        """        Create a new #PangoXftRenderer to allow rendering Pango objects
        with the Xft library. You must call pango_xft_renderer_set_draw() before
        using the renderer.
        @param display: an X display
        @param screen: the index of the screen for @display to which rendering will be done
        @type display: xlib.Display
        @type screen: int
        @returns: Newly created Renderer
        @rtype: Renderer
        """
        return object
    
    def composite_glyphs(self, xft_font=None, glyphs=None, n_glyphs=None):
        """        
        @type xft_font: xft.Font
        @type glyphs: xft.GlyphSpec
        @type n_glyphs: int
        @returns: 
        @rtype: None
        """
        return object
    
    def composite_trapezoids(self, part=None, trapezoids=None, n_trapezoids=None):
        """        
        @type part: Pango.RenderPart
        @type trapezoids: xlib.XTrapezoid
        @type n_trapezoids: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_default_color(self, default_color=None):
        """        Sets the default foreground color for a #XftRenderer.
        @param default_color: the default foreground color
        @type default_color: Pango.Color
        @returns: 
        @rtype: None
        """
        return object
    
    def set_draw(self, draw=None):
        """        Sets the #XftDraw object that the renderer is drawing to.
        The renderer must not be currently active.
        @param draw: a #XftDraw
        @type draw: xft.Draw
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent_instance(self):
        return object

    @property
    def display(self):
        return object

    @property
    def screen(self):
        return object

    @property
    def draw(self):
        return object

    @property
    def priv(self):
        return object


class RendererClass():
    """The class structure for #PangoXftRenderer"""

    @property
    def parent_class(self):
        return object

    @property
    def composite_trapezoids(self):
        return object

    @property
    def composite_glyphs(self):
        return object


class RendererPrivate():
    """"""
